﻿using DoNet.Common.Pages;
using DoNet.Core.Dtos;
using DoNet.ThirdParty.AutoMapper;
using SqlSugar;
using System.Linq.Expressions;

namespace DoNet.Core
{
    /// <summary>
    /// 泛型应用服务接口
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="TODto"></typeparam>
    public interface IService<T, TODto> : IDisposable where T : class
    {
        #region 同步方法
        #region 同步新增
        /// <summary>
        /// 同步新增实体。
        /// </summary>
        /// <param name="entitie">实体集合</param>
        /// <returns></returns>
        int Insert(T entitie);
        /// <summary>
        /// 同步批量新增实体。
        /// </summary>
        /// <param name="entities">实体集合</param>
        /// <returns></returns>
        int Insert(List<T> entities);
        /// <summary>
        /// 同步新增或更新
        /// </summary>
        /// <param name="entities"></param>
        /// <returns>(返回新增数量, 返回更新数量)</returns>
        Tuple<int, int> InsertOrUpdate(List<T> entities);
        #endregion 同步新增

        #region 同步修改
        /// <summary>
        /// 同步按条件更新
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="whereSql">条件语句 如："Age > @Age"</param>
        /// <param name="parameters">条件参数 如：new { Age = 30 }</param>
        /// <returns>执行成功返回true，否则为false。</returns>
        bool Update(T entity, string whereSql = "", object? parameters = null);
        /// <summary>
        /// 同步按条件更新指定字段
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="listColumns">需要更新的字段</param>
        /// <param name="listIgnoreColumns">不用更新的字段</param>
        /// <returns>执行成功返回true，否则为false。</returns>
        bool Update(T entity, IEnumerable<string> listColumns, IEnumerable<string> listIgnoreColumns);
        /// <summary>
        /// 同步按条件更新指定字段
        /// </summary>
        /// <param name="entitys"></param>
        /// <param name="listColumns">需要更新的字段</param>
        /// <param name="listIgnoreColumns">不用更新的字段</param>
        /// <param name="whereSql">条件语句 如："Age > @Age"</param>
        /// <param name="parameters">条件参数 如：new { Age = 30 }</param>
        /// <returns>执行成功返回true，否则为false。</returns>
        bool Update(IEnumerable<T> entitys, IEnumerable<string> listColumns, IEnumerable<string> listIgnoreColumns, string whereSql = "", object? parameters = null);
        /// <summary>
        /// 异步根据id更新
        /// </summary>
        /// <param name="columns">更新的列及值</param>
        /// <param name="id"></param>
        /// <returns>执行成功返回true，否则为false。</returns>
        bool Update(Expression<Func<T, T>> columns, long id);
        /// <summary>
        /// 同步按条件更新（条件语句为空或者条件参数为null时，就代表没有条件，因此使用此方法需谨慎）
        /// </summary>
        /// <param name="columns">更新的列及值</param>
        /// <param name="whereSql">条件语句 如："Age > @Age"</param>
        /// <param name="parameters">条件参数 如：new { Age = 30 }</param>
        /// <returns>执行成功返回true，否则为false。</returns>
        bool Update(Expression<Func<T, T>> columns, string whereSql = "", object? parameters = null);
        #endregion 同步修改

        #region 同步查询
        #region 单个实体
        /// <summary>
        /// 同步根据主键查询单个实体。
        /// </summary>
        /// <param name="id">主键</param>
        /// <returns></returns>
        T GetById(long id);
        /// <summary>
        /// 同步根据条件获取一个对象
        /// </summary>
        /// <param name="whereSql">条件语句 如："Age=@Age"</param>
        /// <param name="parameters">条件参数 如：new { Age=30 }</param>
        /// <returns></returns>
        T? GetByWhere(string whereSql, object parameters);
        /// <summary>
        /// 同步根据条件获取一个对象
        /// 用于返回查询结果的第一条记录，但如果查询结果为空，它将返回 default(T) 值（通常是 null 对于引用类型）
        /// </summary>
        /// <param name="whereExpression">查询条件表达式</param>
        /// <returns></returns>
        T GetFirstByWhere(Expression<Func<T, bool>> whereExpression);
        /// <summary>
        /// 同步根据条件获取一个对象
        /// 用于返回一个单一的结果，如果查询结果有多于一个结果，它会抛出一个异常（通常是 InvalidOperationException)
        /// </summary>
        /// <param name="whereExpression">查询条件表达式</param>
        /// <returns></returns>
        T GetSingleByWhere(Expression<Func<T, bool>> whereExpression);
        /// <summary>
        /// 同步查询单个实体。
        /// </summary>
        /// <param name="id">主键</param>
        /// <returns></returns>
        TODto? GetOutDto(long id);
        #endregion 单个实体

        #region 实体列表
        /// <summary>
        /// 同步查询所有实体。
        /// </summary>        
        /// <returns></returns>
        IEnumerable<T> GetAll();
        /// <summary>
        /// 同步根据查询条件获取数据集合
        /// </summary>
        /// <param name="whereSql">条件语句 如："Age=@Age"</param>
        /// <param name="parameters">条件参数 如：new { Age=30 }</param>
        /// <returns></returns>
        IEnumerable<T>? GetListByWhere(string whereSql = "", object? parameters = null);
        /// <summary>
        /// 同步根据查询条件获取数据集合
        /// </summary>
        /// <param name="whereExpression">查询条件表达式</param>
        /// <returns></returns>
        IEnumerable<T> GetListByWhere(Expression<Func<T, bool>> whereExpression);
        /// <summary>
        /// 同步根据查询条件查询前多少条数据
        /// SQL语句，仅支持SqlServer和Mysql
        /// </summary>
        /// <param name="top">多少条数据</param>
        /// <param name="whereExpression">查询条件表达式</param>
        /// <returns></returns>
        IEnumerable<T> GetListTopWhere(int top, Expression<Func<T, bool>> whereExpression);
        /// <summary>
        /// 同步根据查询条件查询前多少条数据
        /// SQL语句，仅支持SqlServer和Mysql
        /// </summary>
        /// <param name="top">多少条数据</param>
        /// <param name="whereSql">条件语句 如："Age=@Age"</param>
        /// <param name="parameters">条件参数 如：new { Age=30 }</param>
        /// <returns></returns>
        IEnumerable<T>? GetListTopWhere(int top, string whereSql, object parameters);
        /// <summary>
        /// 同步查询对应有效状态的数据
        /// </summary>
        /// <param name="enabledMark">有效状态</param>
        /// <returns></returns>
        IEnumerable<T>? GetAllByEnabledMark(bool enabledMark);
        /// <summary>
        /// 同步查询软删除状态的数据
        /// </summary>
        /// <param name="deleteMark">软删除状态</param>
        /// <returns></returns>
        IEnumerable<T>? GetAllByDeleteMark(bool deleteMark);
        /// <summary>
        /// 同步查询未软删除且有效的数据，如果查询条件为空，即查询所有数据
        /// </summary>
        /// <param name="deleteMark">软删除状态</param>
        /// <param name="enabledMark">有效状态</param>
        /// <returns></returns>
        IEnumerable<T>? GetAllByDeleteMarkAndEnabledMark(bool deleteMark, bool enabledMark);
        #endregion 实体列表

        #region 分页实体列表
        /// <summary>
        /// 根据条件查询数据库,并返回对象集合(用于分页数据显示)
        /// </summary>
        /// <param name="condition">查询的条件</param>
        /// <param name="info">分页实体</param>
        /// <returns>指定对象的集合</returns>
        List<T> FindWithPager(string condition, PagerInfo info);
        /// <summary>
        /// 根据条件查询数据库,并返回对象集合(用于分页数据显示)
        /// </summary>
        /// <param name="condition">查询的条件</param>
        /// <param name="info">分页实体</param>
        /// <param name="fieldToSort">排序字段</param>
        /// <returns>指定对象的集合</returns>
        List<T> FindWithPager(string condition, PagerInfo info, string fieldToSort);
        /// <summary>
        /// 根据条件查询数据库,并返回对象集合(用于分页数据显示)
        /// </summary>
        /// <param name="condition">查询的条件</param>
        /// <param name="info">分页实体</param>
        /// <param name="fieldToSort">排序字段</param>
        /// <param name="desc">是否降序</param>
        /// <returns>指定对象的集合</returns>
        List<T> FindWithPager(string condition, PagerInfo info, string fieldToSort, bool desc);
        /// <summary>
        /// 根据条件查询数据库,并返回对象集合(用于分页数据显示)
        /// 查询条件变换时请重写该方法。
        /// </summary>
        /// <param name="search">查询的条件</param>
        /// <returns>指定对象的集合</returns>
        PageResult<TODto> FindWithPager(SearchInputDto<T> search);
        #endregion 分页实体列表

        #region Count、Max、Min、Sum
        /// <summary>
        /// 同步根据条件统计数据（sql语句方法）
        /// </summary>
        /// <param name="whereSql">条件语句 如："Age=@Age"</param>
        /// <param name="parameters">条件参数 如：new { Age=30 }</param>
        /// <returns></returns>
        int GetCountByWhere(string whereSql = "", object? parameters = null);
        /// <summary>
        /// 同步根据条件统计数据（表达式方法）
        /// </summary>
        /// <param name="whereExpression">查询条件表达式</param>
        /// <returns></returns>
        int GetCountByWhere(Expression<Func<T, bool>> whereExpression);
        /// <summary>
        /// 同步根据条件查询获取某个字段的最大值（sql语句方法）
        /// </summary>
        /// <typeparam name="TResult">最大值的数据类型</typeparam>
        /// <param name="maxField">最大值的字段名称</param>
        /// <param name="whereSql">条件语句 如："Age=@Age"</param>
        /// <param name="parameters">条件参数 如：new { Age=30 }</param>
        /// <returns>返回字段的最小值</returns>
        TResult? GetMaxValueByField<TResult>(string maxField, string whereSql = "", object? parameters = null);
        /// <summary>
        /// 同步根据条件查询获取某个字段的最大值（表达式方法）
        /// </summary>
        /// <typeparam name="TResult">最大值的数据类型</typeparam>
        /// <param name="maxFieldExpression">最大值字段表达式</param>
        /// <param name="whereExpression">查询条件表达式</param>
        /// <returns>返回字段的最小值</returns>
        TResult GetMaxValueByField<TResult>(Expression<Func<T, TResult>> maxFieldExpression, Expression<Func<T, bool>> whereExpression);
        /// <summary>
        /// 同步根据条件查询获取某个字段的最小值（sql语句方法）
        /// </summary>
        /// <typeparam name="TResult">最小值的数据类型</typeparam>
        /// <param name="minField">最小值的字段名称</param>
        /// <param name="whereSql">条件语句 如："Age=@Age"</param>
        /// <param name="parameters">条件参数 如：new { Age=30 }</param>
        /// <returns>返回字段的最小值</returns>
        TResult? GetMinValueByField<TResult>(string minField, string whereSql = "", object? parameters = null);
        /// <summary>
        /// 同步根据条件查询获取某个字段的最小值（表达式方法）
        /// </summary>
        /// <typeparam name="TResult">最小值的数据类型</typeparam>
        /// <param name="minFieldExpression">最小值字段表达式</param>
        /// <param name="whereExpression">查询条件表达式</param>
        /// <returns>返回字段的最小值</returns>
        TResult GetMinValueByField<TResult>(Expression<Func<T, TResult>> minFieldExpression, Expression<Func<T, bool>> whereExpression);
        /// <summary>
        /// 同步根据条件统计某个字段之和,sum(字段)（sql语句方法）
        /// </summary>
        /// <typeparam name="TResult">求和后的数据类型</typeparam>
        /// <param name="sumField">求和的字段名称</param>
        /// <param name="whereSql">条件语句 如："Age=@Age"</param>
        /// <param name="parameters">条件参数 如：new { Age=30 }</param>
        /// <returns></returns>
        TResult? GetSumValueByField<TResult>(string sumField, string whereSql = "", object? parameters = null);
        /// <summary>
        /// 同步根据条件统计某个字段之和,sum(字段)（表达式方法）
        /// </summary>
        /// <typeparam name="TResult">求和后的数据类型</typeparam>
        /// <param name="sumFieldExpression">求和字段表达式</param>
        /// <param name="whereExpression">查询条件表达式</param>
        /// <returns></returns>
        TResult GetSumValueByField<TResult>(Expression<Func<T, TResult>> sumFieldExpression, Expression<Func<T, bool>> whereExpression);
        #endregion Count、Max、Min、Sum
        #endregion 同步查询

        #region 同步删除
        /// <summary>
        /// 同步按主键批量删除
        /// </summary>
        /// <param name="ids">主键Id List集合</param>
        /// <returns>执行成功返回true，否则为false。</returns>
        bool DeleteById(long id);
        /// <summary>
        /// 同步按主键批量删除
        /// </summary>
        /// <param name="ids">主键Id List集合</param>
        /// <returns>执行成功返回true，否则为false。</returns>
        bool DeleteByIds(IEnumerable<long> ids);
        /// <summary>
        /// 异步按条件删除
        /// </summary>
        /// <param name="whereSql">条件语句 如："Age > @Age"</param>
        /// <param name="parameters">条件参数及值 如：new { Age = 30 }</param>
        /// <returns></returns>
        bool DeleteByWhere(string whereSql = "", object? parameters = null);
        #endregion 同步删除

        #region 事务
        /// <summary>
        /// 同步多表多数据操作批量插入、更新、删除--事务
        /// </summary>
        /// <param name="trans">事务</param>
        /// <param name="commandTimeout">超时</param>
        /// <returns></returns>
        Tuple<bool, string> ExecuteTransaction(List<Tuple<string, object?>> trans, int? commandTimeout = null);
        /// <summary>
        /// 同步使用事务
        /// </summary>
        /// <param name="action">事务执行的方法</param>
        /// <returns></returns>
        DbResult<bool> TransactionExecute(Action action);
        #endregion 事务
        #endregion 同步方法

        #region 异步方法
        #region 异步新增
        /// <summary>
        /// 异步新增实体。
        /// </summary>
        /// <param name="entitie">实体集合</param>
        /// <returns></returns>
        Task<int> InsertAsync(T entitie);
        /// <summary>
        /// 异步批量新增实体。
        /// </summary>
        /// <param name="entities">实体集合</param>
        /// <returns></returns>
        Task<int> InsertAsync(List<T> entities);
        /// <summary>
        /// 异步新增或更新
        /// </summary>
        /// <param name="entities"></param>
        /// <returns>(返回新增数量, 返回更新数量)</returns>
        Task<Tuple<int, int>> InsertOrUpdateAsync(List<T> entities);
        #endregion 异步新增

        #region 异步修改
        /// <summary>
        /// 异步按条件更新
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="whereSql">条件语句 如："Age > @Age"</param>
        /// <param name="parameters">条件参数 如：new { Age = 30 }</param>
        /// <returns>执行成功返回true，否则为false。</returns>
        Task<bool> UpdateAsync(T entity, string whereSql = "", object? parameters = null);
        /// <summary>
        /// 异步按条件更新指定字段
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="listColumns">需要更新的字段</param>
        /// <param name="listIgnoreColumns">不用更新的字段</param>
        /// <returns>执行成功返回true，否则为false。</returns>
        Task<bool> UpdateAsync(T entity, IEnumerable<string> listColumns, IEnumerable<string> listIgnoreColumns);
        /// <summary>
        /// 异步按条件更新指定字段
        /// </summary>
        /// <param name="entitys"></param>
        /// <param name="listColumns">需要更新的字段</param>
        /// <param name="listIgnoreColumns">不用更新的字段</param>
        /// <param name="whereSql">条件语句 如："Age > @Age"</param>
        /// <param name="parameters">条件参数 如：new { Age = 30 }</param>
        /// <returns>执行成功返回true，否则为false。</returns>
        Task<bool> UpdateAsync(IEnumerable<T> entitys, IEnumerable<string> listColumns, IEnumerable<string> listIgnoreColumns, string whereSql = "", object? parameters = null);
        /// <summary>
        /// 异步根据id更新
        /// </summary>
        /// <param name="columns">更新的列及值</param>
        /// <param name="id"></param>
        /// <returns>执行成功返回true，否则为false。</returns>
        Task<bool> UpdateAsync(Expression<Func<T, T>> columns, long id);
        /// <summary>
        /// 异步按条件更新（条件语句为空或者条件参数为null时，就代表没有条件，因此使用此方法需谨慎）
        /// </summary>
        /// <param name="columns">更新的列及值</param>
        /// <param name="whereSql">条件语句 如："Age > @Age"</param>
        /// <param name="parameters">条件参数 如：new { Age = 30 }</param>
        /// <returns>执行成功返回true，否则为false。</returns>
        Task<bool> UpdateAsync(Expression<Func<T, T>> columns, string whereSql = "", object? parameters = null);
        #endregion 同步修改

        #region 异步查询
        #region 单个实体
        /// <summary>
        /// 异步根据主键查询单个实体。
        /// </summary>
        /// <param name="id">主键</param>
        /// <returns></returns>
        Task<T> GetByIdAsync(long id);
        /// <summary>
        /// 异步根据条件获取一个对象
        /// </summary>
        /// <param name="whereSql">条件语句 如："Age=@Age"</param>
        /// <param name="parameters">条件参数 如：new { Age=30 }</param>
        /// <returns></returns>
        Task<T> GetByWhereAsync(string whereSql, object parameters);
        /// <summary>
        /// 异步根据条件获取一个对象
        /// 用于返回查询结果的第一条记录，但如果查询结果为空，它将返回 default(T) 值（通常是 null 对于引用类型）
        /// </summary>
        /// <param name="whereExpression"></param>
        /// <returns></returns>
        Task<T> GetFirstByWhereAsync(Expression<Func<T, bool>> whereExpression);
        /// <summary>
        /// 异步根据条件获取一个对象
        /// 用于返回一个单一的结果，如果查询结果有多于一个结果，它会抛出一个异常（通常是 InvalidOperationException)
        /// </summary>
        /// <param name="whereExpression">查询条件表达式</param>
        /// <returns></returns>
        Task<T> GetSingleByWhereAsync(Expression<Func<T, bool>> whereExpression);
        /// <summary>
        /// 异步查询单个实体。
        /// </summary>
        /// <param name="id">主键</param>
        /// <returns></returns>
        Task<TODto?> GetOutDtoAsync(long id);
        #endregion 单个实体

        #region 实体列表
        /// <summary>
        /// 异步获取所有数据，谨慎使用
        /// </summary>
        /// <returns></returns>
        Task<IEnumerable<T>> GetAllAsync();
        /// <summary>
        /// 异步根据查询条件获取数据集合
        /// </summary>
        /// <param name="whereSql">条件语句 如："Age=@Age"</param>
        /// <param name="parameters">条件参数 如：new { Age=30 }</param>
        /// <returns></returns>
        Task<IEnumerable<T>> GetListByWhereAsync(string whereSql, object parameters);
        /// <summary>
        /// 异步根据查询条件获取数据集合
        /// </summary>
        /// <param name="whereExpression">查询条件表达式</param>
        /// <returns></returns>
        Task<IEnumerable<T>> GetListByWhereAsync(Expression<Func<T, bool>> whereExpression);
        /// <summary>
        /// 异步根据查询条件查询前多少条数据
        /// SQL语句，仅支持SqlServer和Mysql
        /// </summary>
        /// <param name="top">多少条数据</param>
        /// <param name="whereExpression">查询条件表达式</param>
        /// <returns></returns>
        Task<IEnumerable<T>> GetListTopWhereAsync(int top, Expression<Func<T, bool>> whereExpression);
        /// <summary>
        /// 异步根据查询条件查询前多少条数据
        /// SQL语句，仅支持SqlServer和Mysql
        /// </summary>
        /// <param name="top">多少条数据</param>
        /// <param name="whereSql">条件语句 如："Age=@Age"</param>
        /// <param name="parameters">条件参数 如：new { Age=30 }</param>
        /// <returns></returns>
        Task<IEnumerable<T>> GetListTopWhereAsync(int top, string whereSql, object parameters);
        /// <summary>
        /// 异步查询对应有效状态的数据
        /// </summary>
        /// <param name="enabledMark">有效状态</param>
        /// <returns></returns>
        Task<IEnumerable<T>> GetAllByEnabledMarkAsync(bool enabledMark);
        /// <summary>
        /// 异步查询软删除状态的数据
        /// </summary>
        /// <param name="deleteMark">软删除状态</param>
        /// <returns></returns>
        Task<IEnumerable<T>> GetAllByDeleteMarkAsync(bool deleteMark);
        /// <summary>
        /// 异步查询未软删除且有效的数据，如果查询条件为空，即查询所有数据
        /// </summary>
        /// <param name="deleteMark">软删除状态</param>
        /// <param name="enabledMark">有效状态</param>
        /// <returns></returns>
        Task<IEnumerable<T>> GetAllByDeleteMarkAndEnabledMarkAsync(bool deleteMark, bool enabledMark);
        #endregion 实体列表

        #region 分页实体列表
        /// <summary>
        /// 根据条件查询数据库,并返回对象集合(用于分页数据显示)
        /// </summary>
        /// <param name="condition">查询的条件</param>
        /// <param name="info">分页实体</param>
        /// <returns>指定对象的集合</returns>
        Task<List<T>> FindWithPagerAsync(string condition, PagerInfo info);
        /// <summary>
        /// 根据条件查询数据库,并返回对象集合(用于分页数据显示)
        /// </summary>
        /// <param name="condition">查询的条件</param>
        /// <param name="info">分页实体</param>
        /// <param name="fieldToSort">排序字段</param>
        /// <returns>指定对象的集合</returns>
        Task<List<T>> FindWithPagerAsync(string condition, PagerInfo info, string fieldToSort);
        /// <summary>
        /// 根据条件查询数据库,并返回对象集合(用于分页数据显示)
        /// </summary>
        /// <param name="condition">查询的条件</param>
        /// <param name="info">分页实体</param>
        /// <param name="fieldToSort">排序字段</param>
        /// <param name="desc">排序方式</param>
        /// <returns>指定对象的集合</returns>
        Task<List<T>> FindWithPagerAsync(string condition, PagerInfo info, string fieldToSort, bool desc);
        /// <summary>
        /// 根据条件查询数据库,并返回对象集合(用于分页数据显示)
        /// 查询条件变换时请重写该方法。
        /// </summary>
        /// <param name="search">查询的条件</param>
        /// <returns>指定对象的集合</returns>
        Task<PageResult<TODto>> FindWithPagerAsync(SearchInputDto<T> search);
        #endregion 分页实体列表

        #region Count、Max、Min、Sum
        /// <summary>
        /// 异步根据条件统计数据（sql语句方法）
        /// </summary>
        /// <param name="whereSql">条件语句 如："Age=@Age"</param>
        /// <param name="parameters">条件参数 如：new { Age=30 }</param>
        /// <returns></returns>
        Task<int> GetCountByWhereAsync(string whereSql = "", object? parameters = null);
        /// <summary>
        /// 异步根据条件统计数据（表达式方法）
        /// </summary>
        /// <param name="whereExpression">查询条件表达式</param>
        /// <returns></returns>
        Task<int> GetCountByWhereAsync(Expression<Func<T, bool>> whereExpression);
        /// <summary>
        /// 异步根据条件查询获取某个字段的最大值（sql语句方法）
        /// </summary>
        /// <typeparam name="TResult">最大值的数据类型</typeparam>
        /// <param name="maxField">最大值的字段名称</param>
        /// <param name="whereSql">条件语句 如："Age=@Age"</param>
        /// <param name="parameters">条件参数 如：new { Age=30 }</param>
        /// <returns>返回字段的最小值</returns>
        Task<TResult> GetMaxValueByFieldAsync<TResult>(string maxField, string whereSql = "", object? parameters = null);
        /// <summary>
        /// 异步根据条件查询获取某个字段的最大值（表达式方法）
        /// </summary>
        /// <typeparam name="TResult">最大值的数据类型</typeparam>
        /// <param name="maxFieldExpression">最大值字段表达式</param>
        /// <param name="whereExpression">查询条件表达式</param>
        /// <returns>返回字段的最小值</returns>
        Task<TResult> GetMaxValueByFieldAsync<TResult>(Expression<Func<T, TResult>> maxFieldExpression, Expression<Func<T, bool>> whereExpression);
        /// <summary>
        /// 异步根据条件查询获取某个字段的最小值（sql语句方法）
        /// </summary>
        /// <typeparam name="TResult">最小值的数据类型</typeparam>
        /// <param name="minField">最小值的字段名称</param>
        /// <param name="whereSql">条件语句 如："Age=@Age"</param>
        /// <param name="parameters">条件参数 如：new { Age=30 }</param>
        /// <returns>返回字段的最小值</returns>
        Task<TResult> GetMinValueByFieldAsync<TResult>(string minField, string whereSql = "", object? parameters = null);
        /// <summary>
        /// 异步根据条件查询获取某个字段的最小值（表达式方法）
        /// </summary>
        /// <typeparam name="TResult">最小值的数据类型</typeparam>
        /// <param name="minFieldExpression">最小值字段表达式</param>
        /// <param name="whereExpression">查询条件表达式</param>
        /// <returns>返回字段的最小值</returns>
        Task<TResult> GetMinValueByFieldAsync<TResult>(Expression<Func<T, TResult>> minFieldExpression, Expression<Func<T, bool>> whereExpression);
        /// <summary>
        /// 异步根据条件统计某个字段之和,sum(字段)（sql语句方法）
        /// </summary>
        /// <typeparam name="TResult">求和后的数据类型</typeparam>
        /// <param name="sumField">求和的字段名称</param>
        /// <param name="whereSql">条件语句 如："Age=@Age"</param>
        /// <param name="parameters">条件参数 如：new { Age=30 }</param>
        /// <returns></returns>
        Task<TResult> GetSumValueByFieldAsync<TResult>(string sumField, string whereSql = "", object? parameters = null);
        /// <summary>
        /// 异步根据条件统计某个字段之和,sum(字段)（表达式方法）
        /// </summary>
        /// <typeparam name="TResult">求和后的数据类型</typeparam>
        /// <param name="sumFieldExpression">求和字段表达式</param>
        /// <param name="whereExpression">查询条件表达式</param>
        /// <returns></returns>
        Task<TResult> GetSumValueByFieldAsync<TResult>(Expression<Func<T, TResult>> sumFieldExpression, Expression<Func<T, bool>> whereExpression);
        #endregion Count、Max、Min、Sum
        #endregion 异步查询

        #region 异步删除
        /// <summary>
        /// 异步按主键删除
        /// </summary>
        /// <param name="id">主键Id List集合</param>
        /// <returns>执行成功返回true，否则为false。</returns>
        Task<bool> DeleteByIdAsync(long id);
        /// <summary>
        /// 异步按主键批量删除
        /// </summary>
        /// <param name="ids">主键Id List集合</param>
        /// <returns>执行成功返回true，否则为false。</returns>
        Task<bool> DeleteByIdsAsync(IEnumerable<long> ids);
        /// <summary>
        /// 异步按条件删除
        /// </summary>
        /// <param name="whereSql">条件语句 如："Age > @Age"</param>
        /// <param name="parameters">条件参数及值 如：new { Age = 30 }</param>
        /// <returns></returns>
        Task<bool> DeleteByWhereAsync(string whereSql = "", object? parameters = null);
        #endregion 异步删除

        #region 事务
        /// <summary>
        /// 异步多表多数据操作批量插入、更新、删除--事务
        /// </summary>
        /// <param name="trans">事务</param>
        /// <param name="commandTimeout">超时</param>
        /// <returns></returns>
        Task<Tuple<bool, string>> ExecuteTransactionAsync(List<Tuple<string, object?>> trans, int? commandTimeout = null);
        /// <summary>
        /// 异步使用事务
        /// </summary>
        /// <param name="action">事务执行的方法</param>
        /// <returns></returns>
        Task<DbResult<bool>> UseTranAsync(Func<Task> action);
        #endregion 事务
        #endregion 异步方法
    }
}
